package bo;

import IBO.IClientParticulier;
import boerrors.ClientParticulierInexistantException;
import dao.AbstractFactory;
import dao.dto.AdresseDto;
import dao.dto.ClientParticulierDto;
import boerrors.AdresseMinimumMultiplicityException;
import boerrors.ClientParticulierExistantException;
import boerrors.CodePostalMinimumMultiplicityException;
import boerrors.ZoneMinimumMultiplicityException;
import dao.dto.CodePostalDto;
import dao.dto.ZoneDto;
import java.io.Serializable;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ClientParticulier extends Client implements IClientParticulier, Serializable, Cloneable{
        
	//*******************************************************************
	//Constructeurs
	//*******************************************************************
        
        //Constructeur utilisé lors de la remontée des informations en provenance de la DAO
        public ClientParticulier(ClientParticulierDto clientP) throws RemoteException{
                //Obligation de mettre un super en premier, donc instanciation sans l'objet Adresse qui a encore besoin d'être convertit
                super(clientP.getNom(), clientP.getPrenom(), clientP.getTelephone(), clientP.getEmail(), clientP.getIdClient(),
                      clientP.getNumeroTVA());             
                //Convertion de l'objet AdresseDto en Adresse
                Adresse adresse = new Adresse(clientP.getAdresse());
                //Ajout de l'objet Adresse
                this.setAdresse(adresse);
                UnicastRemoteObject.exportObject(this, 0);
        }
    
        public ClientParticulier(   String nom, String prenom, Adresse adresse,
                                    String telephone, String email, String numeroTVA) throws RemoteException {
                super(nom, prenom, adresse, telephone, email, numeroTVA);
                try {
                    int idClient;
                    idClient = AbstractFactory.getInstance().getClientParticulierDao().enregistrer(creerClientParticulierDto());
                    this.setIdClient(idClient);
                    ListeClients.getInstance().ajouterClientParticulier(this);
                    UnicastRemoteObject.exportObject(this, 0);
                } catch (AdresseMinimumMultiplicityException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                } catch (CodePostalMinimumMultiplicityException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ZoneMinimumMultiplicityException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ClientParticulierExistantException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                }
        }

        public ClientParticulier(   String nom, String prenom, Adresse adresse, 
                                    String telephone, String email) throws  RemoteException {
                super(nom, prenom, adresse, telephone, email);
                try {
                    int idClient;
                    idClient = AbstractFactory.getInstance().getClientParticulierDao().enregistrer(creerClientParticulierDto());
                    this.setIdClient(idClient);
                    ListeClients.getInstance().ajouterClientParticulier(this);
                    UnicastRemoteObject.exportObject(this, 0);
                } catch (AdresseMinimumMultiplicityException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                } catch (CodePostalMinimumMultiplicityException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ZoneMinimumMultiplicityException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                } catch (ClientParticulierExistantException ex) {
                    Logger.getLogger(ClientParticulier.class.getName()).log(Level.SEVERE, null, ex);
                }
        }

        public ClientParticulier(   int idClient, String nom, String prenom, Adresse adresse, String email, 
                                    String telephone) throws RemoteException {
                super(nom, prenom, adresse, telephone, email, idClient);
                UnicastRemoteObject.exportObject(this, 0);
        }

        public ClientParticulier(   int idClient, String nom, String prenom, Adresse adresse, String email, 
                                    String telephone, String numeroTVA) throws RemoteException {
                super(nom, prenom, adresse, telephone, email, idClient, numeroTVA);
                UnicastRemoteObject.exportObject(this, 0);
        }
        
        public ClientParticulierDto creerClientParticulierDto() throws RemoteException, AdresseMinimumMultiplicityException, 
                                                                        CodePostalMinimumMultiplicityException, 
                                                                        ZoneMinimumMultiplicityException {
                ZoneDto zTampon = new ZoneDto(  this.getAdresse().getCodePostal().getZone().getIdZone(), 
                                                this.getAdresse().getCodePostal().getZone().getLibelleZone());
                CodePostalDto cpTampon = new CodePostalDto( this.getAdresse().getCodePostal().getIdCodePostal(), 
                                                            this.getAdresse().getCodePostal().getCodePostal(),
                                                            this.getAdresse().getCodePostal().getVille(), 
                                                            this.getAdresse().getCodePostal().getPays(),zTampon);
                AdresseDto tampon = new AdresseDto( this.getAdresse().getIdAdresse(), this.getAdresse().getRue(), 
                                                    this.getAdresse().getNumero(), cpTampon);
                return new ClientParticulierDto(    this.getIdClient(),  this.getNom(), this.getPrenom(), this.getNumeroTva(),
                                                    tampon, this.getTelephone(),this.getEmail());
        }
        
        //*******************************************************************
	//Methodes static
	//*******************************************************************
        
        public synchronized static Vector<ClientParticulier> lister()throws RemoteException, ClientParticulierInexistantException {
                Vector<ClientParticulierDto> listeClientPDto = AbstractFactory.getInstance().getClientParticulierDao().lister();
                Vector<ClientParticulier> listeClient = new Vector<ClientParticulier>();
                for (int i = 0; i < listeClientPDto.size(); i++){
                    ClientParticulierDto clDto = listeClientPDto.get(i);
                    listeClient.add(new ClientParticulier(clDto));
                }
                return listeClient;
        }
        
        public synchronized static void modifier(ClientParticulier client) throws   RemoteException, ClientParticulierInexistantException, 
                                                                                    AdresseMinimumMultiplicityException, 
                                                                                    CodePostalMinimumMultiplicityException, 
                                                                                    ZoneMinimumMultiplicityException {
                AbstractFactory.getInstance().getClientParticulierDao().modifier(client.creerClientParticulierDto());
        }

        //*******************************************************************
	//Method Clonable
	//*******************************************************************        
        
        @Override
        public Object clone(){
            // On recupere l'instance à renvoyer par l'appel de la 
	    // methode super.clone() (ici : Personne.clone())
             ClientParticulier clientParticulier = (ClientParticulier) super.clone();
            // on renvoie le clone
            return clientParticulier;
        }
}